//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2024 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto-codegenerator.
// DO NOT EDIT.

#if canImport(FoundationEssentials)
import FoundationEssentials
#else
import Foundation
#endif
@_exported import SotoCore

/// Service object for interacting with AWS S3Tables service.
///
/// An Amazon S3 table represents a structured dataset consisting of tabular data in Apache Parquet format and related metadata. This data is stored inside an S3 table as a subresource. All tables in a table bucket are stored in the Apache Iceberg table format. Through integration with the Amazon Web Services Glue Data Catalog you can interact with your tables using Amazon Web Services analytics services, such as Amazon Athena and Amazon Redshift. Amazon S3 manages maintenance of your tables through automatic file compaction and snapshot management. For more information, see Amazon S3 table buckets.
public struct S3Tables: AWSService {
    // MARK: Member variables

    /// Client used for communication with AWS
    public let client: AWSClient
    /// Service configuration
    public let config: AWSServiceConfig

    // MARK: Initialization

    /// Initialize the S3Tables client
    /// - parameters:
    ///     - client: AWSClient used to process requests
    ///     - region: Region of server you want to communicate with. This will override the partition parameter.
    ///     - partition: AWS partition where service resides, standard (.aws), china (.awscn), government (.awsusgov).
    ///     - endpoint: Custom endpoint URL to use instead of standard AWS servers
    ///     - middleware: Middleware chain used to edit requests before they are sent and responses before they are decoded 
    ///     - timeout: Timeout value for HTTP requests
    ///     - byteBufferAllocator: Allocator for ByteBuffers
    ///     - options: Service options
    public init(
        client: AWSClient,
        region: SotoCore.Region? = nil,
        partition: AWSPartition = .aws,
        endpoint: String? = nil,
        middleware: AWSMiddlewareProtocol? = nil,
        timeout: TimeAmount? = nil,
        byteBufferAllocator: ByteBufferAllocator = ByteBufferAllocator(),
        options: AWSServiceConfig.Options = []
    ) {
        self.client = client
        self.config = AWSServiceConfig(
            region: region,
            partition: region?.partition ?? partition,
            serviceName: "S3Tables",
            serviceIdentifier: "s3tables",
            serviceProtocol: .restjson,
            apiVersion: "2018-05-10",
            endpoint: endpoint,
            errorType: S3TablesErrorType.self,
            middleware: middleware,
            timeout: timeout,
            byteBufferAllocator: byteBufferAllocator,
            options: options
        )
    }





    // MARK: API Calls

    /// Creates a namespace. A namespace is a logical grouping of tables within your table bucket, which you can use to organize tables. For more information, see Create a namespace in the Amazon Simple Storage Service User Guide.  Permissions  You must have the s3tables:CreateNamespace permission to use this operation.
    @Sendable
    @inlinable
    public func createNamespace(_ input: CreateNamespaceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateNamespaceResponse {
        try await self.client.execute(
            operation: "CreateNamespace", 
            path: "/namespaces/{tableBucketARN}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a namespace. A namespace is a logical grouping of tables within your table bucket, which you can use to organize tables. For more information, see Create a namespace in the Amazon Simple Storage Service User Guide.  Permissions  You must have the s3tables:CreateNamespace permission to use this operation.
    ///
    /// Parameters:
    ///   - namespace: A name for the namespace.
    ///   - tableBucketARN: The Amazon Resource Name (ARN) of the table bucket to create the namespace in.
    ///   - logger: Logger use during operation
    @inlinable
    public func createNamespace(
        namespace: [String],
        tableBucketARN: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateNamespaceResponse {
        let input = CreateNamespaceRequest(
            namespace: namespace, 
            tableBucketARN: tableBucketARN
        )
        return try await self.createNamespace(input, logger: logger)
    }

    /// Creates a new table associated with the given namespace in a table bucket. For more information, see Creating an Amazon S3 table in the Amazon Simple Storage Service User Guide.  Permissions    You must have the s3tables:CreateTable permission to use this operation.    If you use this operation with the optional metadata request parameter you must have the s3tables:PutTableData permission.    If you use this operation with the optional encryptionConfiguration request parameter you must have the s3tables:PutTableEncryption permission.     Additionally, If you choose SSE-KMS encryption you must grant the S3 Tables maintenance principal access to your KMS key. For more information, see Permissions requirements for S3 Tables SSE-KMS encryption.
    @Sendable
    @inlinable
    public func createTable(_ input: CreateTableRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateTableResponse {
        try await self.client.execute(
            operation: "CreateTable", 
            path: "/tables/{tableBucketARN}/{namespace}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new table associated with the given namespace in a table bucket. For more information, see Creating an Amazon S3 table in the Amazon Simple Storage Service User Guide.  Permissions    You must have the s3tables:CreateTable permission to use this operation.    If you use this operation with the optional metadata request parameter you must have the s3tables:PutTableData permission.    If you use this operation with the optional encryptionConfiguration request parameter you must have the s3tables:PutTableEncryption permission.     Additionally, If you choose SSE-KMS encryption you must grant the S3 Tables maintenance principal access to your KMS key. For more information, see Permissions requirements for S3 Tables SSE-KMS encryption.
    ///
    /// Parameters:
    ///   - encryptionConfiguration: The encryption configuration to use for the table. This configuration specifies the encryption algorithm and, if using SSE-KMS, the KMS key to use for encrypting the table.   If you choose SSE-KMS encryption you must grant the S3 Tables maintenance principal access to your KMS key. For more information, see Permissions requirements for S3 Tables SSE-KMS encryption.
    ///   - format: The format for the table.
    ///   - metadata: The metadata for the table.
    ///   - name: The name for the table.
    ///   - namespace: The namespace to associated with the table.
    ///   - tableBucketARN: The Amazon Resource Name (ARN) of the table bucket to create the table in.
    ///   - logger: Logger use during operation
    @inlinable
    public func createTable(
        encryptionConfiguration: EncryptionConfiguration? = nil,
        format: OpenTableFormat,
        metadata: TableMetadata? = nil,
        name: String,
        namespace: String,
        tableBucketARN: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateTableResponse {
        let input = CreateTableRequest(
            encryptionConfiguration: encryptionConfiguration, 
            format: format, 
            metadata: metadata, 
            name: name, 
            namespace: namespace, 
            tableBucketARN: tableBucketARN
        )
        return try await self.createTable(input, logger: logger)
    }

    /// Creates a table bucket. For more information, see Creating a table bucket in the Amazon Simple Storage Service User Guide.  Permissions    You must have the s3tables:CreateTableBucket permission to use this operation.    If you use this operation with the optional encryptionConfiguration parameter you must have the s3tables:PutTableBucketEncryption permission.
    @Sendable
    @inlinable
    public func createTableBucket(_ input: CreateTableBucketRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateTableBucketResponse {
        try await self.client.execute(
            operation: "CreateTableBucket", 
            path: "/buckets", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a table bucket. For more information, see Creating a table bucket in the Amazon Simple Storage Service User Guide.  Permissions    You must have the s3tables:CreateTableBucket permission to use this operation.    If you use this operation with the optional encryptionConfiguration parameter you must have the s3tables:PutTableBucketEncryption permission.
    ///
    /// Parameters:
    ///   - encryptionConfiguration: The encryption configuration to use for the table bucket. This configuration specifies the default encryption settings that will be applied to all tables created in this bucket unless overridden at the table level. The configuration includes the encryption algorithm and, if using SSE-KMS, the KMS key to use.
    ///   - name: The name for the table bucket.
    ///   - logger: Logger use during operation
    @inlinable
    public func createTableBucket(
        encryptionConfiguration: EncryptionConfiguration? = nil,
        name: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateTableBucketResponse {
        let input = CreateTableBucketRequest(
            encryptionConfiguration: encryptionConfiguration, 
            name: name
        )
        return try await self.createTableBucket(input, logger: logger)
    }

    /// Deletes a namespace. For more information, see Delete a namespace in the Amazon Simple Storage Service User Guide.  Permissions  You must have the s3tables:DeleteNamespace permission to use this operation.
    @Sendable
    @inlinable
    public func deleteNamespace(_ input: DeleteNamespaceRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteNamespace", 
            path: "/namespaces/{tableBucketARN}/{namespace}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a namespace. For more information, see Delete a namespace in the Amazon Simple Storage Service User Guide.  Permissions  You must have the s3tables:DeleteNamespace permission to use this operation.
    ///
    /// Parameters:
    ///   - namespace: The name of the namespace.
    ///   - tableBucketARN: The Amazon Resource Name (ARN) of the table bucket associated with the namespace.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteNamespace(
        namespace: String,
        tableBucketARN: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteNamespaceRequest(
            namespace: namespace, 
            tableBucketARN: tableBucketARN
        )
        return try await self.deleteNamespace(input, logger: logger)
    }

    /// Deletes a table. For more information, see Deleting an Amazon S3 table in the Amazon Simple Storage Service User Guide.  Permissions  You must have the s3tables:DeleteTable permission to use this operation.
    @Sendable
    @inlinable
    public func deleteTable(_ input: DeleteTableRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteTable", 
            path: "/tables/{tableBucketARN}/{namespace}/{name}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a table. For more information, see Deleting an Amazon S3 table in the Amazon Simple Storage Service User Guide.  Permissions  You must have the s3tables:DeleteTable permission to use this operation.
    ///
    /// Parameters:
    ///   - name: The name of the table.
    ///   - namespace: The namespace associated with the table.
    ///   - tableBucketARN: The Amazon Resource Name (ARN) of the table bucket that contains the table.
    ///   - versionToken: The version token of the table.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteTable(
        name: String,
        namespace: String,
        tableBucketARN: String,
        versionToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteTableRequest(
            name: name, 
            namespace: namespace, 
            tableBucketARN: tableBucketARN, 
            versionToken: versionToken
        )
        return try await self.deleteTable(input, logger: logger)
    }

    /// Deletes a table bucket. For more information, see Deleting a table bucket in the Amazon Simple Storage Service User Guide.  Permissions  You must have the s3tables:DeleteTableBucket permission to use this operation.
    @Sendable
    @inlinable
    public func deleteTableBucket(_ input: DeleteTableBucketRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteTableBucket", 
            path: "/buckets/{tableBucketARN}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a table bucket. For more information, see Deleting a table bucket in the Amazon Simple Storage Service User Guide.  Permissions  You must have the s3tables:DeleteTableBucket permission to use this operation.
    ///
    /// Parameters:
    ///   - tableBucketARN: The Amazon Resource Name (ARN) of the table bucket.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteTableBucket(
        tableBucketARN: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteTableBucketRequest(
            tableBucketARN: tableBucketARN
        )
        return try await self.deleteTableBucket(input, logger: logger)
    }

    /// Deletes the encryption configuration for a table bucket.  Permissions  You must have the s3tables:DeleteTableBucketEncryption permission to use this operation.
    @Sendable
    @inlinable
    public func deleteTableBucketEncryption(_ input: DeleteTableBucketEncryptionRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteTableBucketEncryption", 
            path: "/buckets/{tableBucketARN}/encryption", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the encryption configuration for a table bucket.  Permissions  You must have the s3tables:DeleteTableBucketEncryption permission to use this operation.
    ///
    /// Parameters:
    ///   - tableBucketARN: The Amazon Resource Name (ARN) of the table bucket.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteTableBucketEncryption(
        tableBucketARN: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteTableBucketEncryptionRequest(
            tableBucketARN: tableBucketARN
        )
        return try await self.deleteTableBucketEncryption(input, logger: logger)
    }

    /// Deletes a table bucket policy. For more information, see Deleting a table bucket policy in the Amazon Simple Storage Service User Guide.  Permissions  You must have the s3tables:DeleteTableBucketPolicy permission to use this operation.
    @Sendable
    @inlinable
    public func deleteTableBucketPolicy(_ input: DeleteTableBucketPolicyRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteTableBucketPolicy", 
            path: "/buckets/{tableBucketARN}/policy", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a table bucket policy. For more information, see Deleting a table bucket policy in the Amazon Simple Storage Service User Guide.  Permissions  You must have the s3tables:DeleteTableBucketPolicy permission to use this operation.
    ///
    /// Parameters:
    ///   - tableBucketARN: The Amazon Resource Name (ARN) of the table bucket.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteTableBucketPolicy(
        tableBucketARN: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteTableBucketPolicyRequest(
            tableBucketARN: tableBucketARN
        )
        return try await self.deleteTableBucketPolicy(input, logger: logger)
    }

    /// Deletes a table policy. For more information, see Deleting a table policy in the Amazon Simple Storage Service User Guide.  Permissions  You must have the s3tables:DeleteTablePolicy permission to use this operation.
    @Sendable
    @inlinable
    public func deleteTablePolicy(_ input: DeleteTablePolicyRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteTablePolicy", 
            path: "/tables/{tableBucketARN}/{namespace}/{name}/policy", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a table policy. For more information, see Deleting a table policy in the Amazon Simple Storage Service User Guide.  Permissions  You must have the s3tables:DeleteTablePolicy permission to use this operation.
    ///
    /// Parameters:
    ///   - name: The table name.
    ///   - namespace: The namespace associated with the table.
    ///   - tableBucketARN: The Amazon Resource Name (ARN) of the table bucket that contains the table.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteTablePolicy(
        name: String,
        namespace: String,
        tableBucketARN: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteTablePolicyRequest(
            name: name, 
            namespace: namespace, 
            tableBucketARN: tableBucketARN
        )
        return try await self.deleteTablePolicy(input, logger: logger)
    }

    /// Gets details about a namespace. For more information, see Table namespaces in the Amazon Simple Storage Service User Guide.  Permissions  You must have the s3tables:GetNamespace permission to use this operation.
    @Sendable
    @inlinable
    public func getNamespace(_ input: GetNamespaceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetNamespaceResponse {
        try await self.client.execute(
            operation: "GetNamespace", 
            path: "/namespaces/{tableBucketARN}/{namespace}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets details about a namespace. For more information, see Table namespaces in the Amazon Simple Storage Service User Guide.  Permissions  You must have the s3tables:GetNamespace permission to use this operation.
    ///
    /// Parameters:
    ///   - namespace: The name of the namespace.
    ///   - tableBucketARN: The Amazon Resource Name (ARN) of the table bucket.
    ///   - logger: Logger use during operation
    @inlinable
    public func getNamespace(
        namespace: String,
        tableBucketARN: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetNamespaceResponse {
        let input = GetNamespaceRequest(
            namespace: namespace, 
            tableBucketARN: tableBucketARN
        )
        return try await self.getNamespace(input, logger: logger)
    }

    /// Gets details about a table. For more information, see S3 Tables in the Amazon Simple Storage Service User Guide.  Permissions  You must have the s3tables:GetTable permission to use this operation.
    @Sendable
    @inlinable
    public func getTable(_ input: GetTableRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetTableResponse {
        try await self.client.execute(
            operation: "GetTable", 
            path: "/get-table", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets details about a table. For more information, see S3 Tables in the Amazon Simple Storage Service User Guide.  Permissions  You must have the s3tables:GetTable permission to use this operation.
    ///
    /// Parameters:
    ///   - name: The name of the table.
    ///   - namespace: The name of the namespace the table is associated with.
    ///   - tableArn: The Amazon Resource Name (ARN) of the table.
    ///   - tableBucketARN: The Amazon Resource Name (ARN) of the table bucket associated with the table.
    ///   - logger: Logger use during operation
    @inlinable
    public func getTable(
        name: String? = nil,
        namespace: String? = nil,
        tableArn: String? = nil,
        tableBucketARN: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetTableResponse {
        let input = GetTableRequest(
            name: name, 
            namespace: namespace, 
            tableArn: tableArn, 
            tableBucketARN: tableBucketARN
        )
        return try await self.getTable(input, logger: logger)
    }

    /// Gets details on a table bucket. For more information, see Viewing details about an Amazon S3 table bucket in the Amazon Simple Storage Service User Guide.  Permissions  You must have the s3tables:GetTableBucket permission to use this operation.
    @Sendable
    @inlinable
    public func getTableBucket(_ input: GetTableBucketRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetTableBucketResponse {
        try await self.client.execute(
            operation: "GetTableBucket", 
            path: "/buckets/{tableBucketARN}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets details on a table bucket. For more information, see Viewing details about an Amazon S3 table bucket in the Amazon Simple Storage Service User Guide.  Permissions  You must have the s3tables:GetTableBucket permission to use this operation.
    ///
    /// Parameters:
    ///   - tableBucketARN: The Amazon Resource Name (ARN) of the table bucket.
    ///   - logger: Logger use during operation
    @inlinable
    public func getTableBucket(
        tableBucketARN: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetTableBucketResponse {
        let input = GetTableBucketRequest(
            tableBucketARN: tableBucketARN
        )
        return try await self.getTableBucket(input, logger: logger)
    }

    /// Gets the encryption configuration for a table bucket.  Permissions  You must have the s3tables:GetTableBucketEncryption permission to use this operation.
    @Sendable
    @inlinable
    public func getTableBucketEncryption(_ input: GetTableBucketEncryptionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetTableBucketEncryptionResponse {
        try await self.client.execute(
            operation: "GetTableBucketEncryption", 
            path: "/buckets/{tableBucketARN}/encryption", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the encryption configuration for a table bucket.  Permissions  You must have the s3tables:GetTableBucketEncryption permission to use this operation.
    ///
    /// Parameters:
    ///   - tableBucketARN: The Amazon Resource Name (ARN) of the table bucket.
    ///   - logger: Logger use during operation
    @inlinable
    public func getTableBucketEncryption(
        tableBucketARN: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetTableBucketEncryptionResponse {
        let input = GetTableBucketEncryptionRequest(
            tableBucketARN: tableBucketARN
        )
        return try await self.getTableBucketEncryption(input, logger: logger)
    }

    /// Gets details about a maintenance configuration for a given table bucket. For more information, see Amazon S3 table bucket maintenance in the Amazon Simple Storage Service User Guide.  Permissions  You must have the s3tables:GetTableBucketMaintenanceConfiguration permission to use this operation.
    @Sendable
    @inlinable
    public func getTableBucketMaintenanceConfiguration(_ input: GetTableBucketMaintenanceConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetTableBucketMaintenanceConfigurationResponse {
        try await self.client.execute(
            operation: "GetTableBucketMaintenanceConfiguration", 
            path: "/buckets/{tableBucketARN}/maintenance", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets details about a maintenance configuration for a given table bucket. For more information, see Amazon S3 table bucket maintenance in the Amazon Simple Storage Service User Guide.  Permissions  You must have the s3tables:GetTableBucketMaintenanceConfiguration permission to use this operation.
    ///
    /// Parameters:
    ///   - tableBucketARN: The Amazon Resource Name (ARN) of the table bucket associated with the maintenance configuration.
    ///   - logger: Logger use during operation
    @inlinable
    public func getTableBucketMaintenanceConfiguration(
        tableBucketARN: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetTableBucketMaintenanceConfigurationResponse {
        let input = GetTableBucketMaintenanceConfigurationRequest(
            tableBucketARN: tableBucketARN
        )
        return try await self.getTableBucketMaintenanceConfiguration(input, logger: logger)
    }

    /// Gets details about a table bucket policy. For more information, see Viewing a table bucket policy in the Amazon Simple Storage Service User Guide.  Permissions  You must have the s3tables:GetTableBucketPolicy permission to use this operation.
    @Sendable
    @inlinable
    public func getTableBucketPolicy(_ input: GetTableBucketPolicyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetTableBucketPolicyResponse {
        try await self.client.execute(
            operation: "GetTableBucketPolicy", 
            path: "/buckets/{tableBucketARN}/policy", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets details about a table bucket policy. For more information, see Viewing a table bucket policy in the Amazon Simple Storage Service User Guide.  Permissions  You must have the s3tables:GetTableBucketPolicy permission to use this operation.
    ///
    /// Parameters:
    ///   - tableBucketARN: The Amazon Resource Name (ARN) of the table bucket.
    ///   - logger: Logger use during operation
    @inlinable
    public func getTableBucketPolicy(
        tableBucketARN: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetTableBucketPolicyResponse {
        let input = GetTableBucketPolicyRequest(
            tableBucketARN: tableBucketARN
        )
        return try await self.getTableBucketPolicy(input, logger: logger)
    }

    /// Gets the encryption configuration for a table.  Permissions  You must have the s3tables:GetTableEncryption permission to use this operation.
    @Sendable
    @inlinable
    public func getTableEncryption(_ input: GetTableEncryptionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetTableEncryptionResponse {
        try await self.client.execute(
            operation: "GetTableEncryption", 
            path: "/tables/{tableBucketARN}/{namespace}/{name}/encryption", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the encryption configuration for a table.  Permissions  You must have the s3tables:GetTableEncryption permission to use this operation.
    ///
    /// Parameters:
    ///   - name: The name of the table.
    ///   - namespace: The namespace associated with the table.
    ///   - tableBucketARN: The Amazon Resource Name (ARN) of the table bucket containing the table.
    ///   - logger: Logger use during operation
    @inlinable
    public func getTableEncryption(
        name: String,
        namespace: String,
        tableBucketARN: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetTableEncryptionResponse {
        let input = GetTableEncryptionRequest(
            name: name, 
            namespace: namespace, 
            tableBucketARN: tableBucketARN
        )
        return try await self.getTableEncryption(input, logger: logger)
    }

    /// Gets details about the maintenance configuration of a table. For more information, see S3 Tables maintenance in the Amazon Simple Storage Service User Guide.  Permissions    You must have the s3tables:GetTableMaintenanceConfiguration permission to use this operation.    You must have the s3tables:GetTableData permission to use set the compaction strategy to sort or zorder.
    @Sendable
    @inlinable
    public func getTableMaintenanceConfiguration(_ input: GetTableMaintenanceConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetTableMaintenanceConfigurationResponse {
        try await self.client.execute(
            operation: "GetTableMaintenanceConfiguration", 
            path: "/tables/{tableBucketARN}/{namespace}/{name}/maintenance", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets details about the maintenance configuration of a table. For more information, see S3 Tables maintenance in the Amazon Simple Storage Service User Guide.  Permissions    You must have the s3tables:GetTableMaintenanceConfiguration permission to use this operation.    You must have the s3tables:GetTableData permission to use set the compaction strategy to sort or zorder.
    ///
    /// Parameters:
    ///   - name: The name of the table.
    ///   - namespace: The namespace associated with the table.
    ///   - tableBucketARN: The Amazon Resource Name (ARN) of the table bucket.
    ///   - logger: Logger use during operation
    @inlinable
    public func getTableMaintenanceConfiguration(
        name: String,
        namespace: String,
        tableBucketARN: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetTableMaintenanceConfigurationResponse {
        let input = GetTableMaintenanceConfigurationRequest(
            name: name, 
            namespace: namespace, 
            tableBucketARN: tableBucketARN
        )
        return try await self.getTableMaintenanceConfiguration(input, logger: logger)
    }

    /// Gets the status of a maintenance job for a table. For more information, see S3 Tables maintenance in the Amazon Simple Storage Service User Guide.  Permissions  You must have the s3tables:GetTableMaintenanceJobStatus permission to use this operation.
    @Sendable
    @inlinable
    public func getTableMaintenanceJobStatus(_ input: GetTableMaintenanceJobStatusRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetTableMaintenanceJobStatusResponse {
        try await self.client.execute(
            operation: "GetTableMaintenanceJobStatus", 
            path: "/tables/{tableBucketARN}/{namespace}/{name}/maintenance-job-status", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the status of a maintenance job for a table. For more information, see S3 Tables maintenance in the Amazon Simple Storage Service User Guide.  Permissions  You must have the s3tables:GetTableMaintenanceJobStatus permission to use this operation.
    ///
    /// Parameters:
    ///   - name: The name of the maintenance job.
    ///   - namespace: The name of the namespace the table is associated with.
    ///   - tableBucketARN: The Amazon Resource Name (ARN) of the table bucket.
    ///   - logger: Logger use during operation
    @inlinable
    public func getTableMaintenanceJobStatus(
        name: String,
        namespace: String,
        tableBucketARN: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetTableMaintenanceJobStatusResponse {
        let input = GetTableMaintenanceJobStatusRequest(
            name: name, 
            namespace: namespace, 
            tableBucketARN: tableBucketARN
        )
        return try await self.getTableMaintenanceJobStatus(input, logger: logger)
    }

    /// Gets the location of the table metadata.  Permissions  You must have the s3tables:GetTableMetadataLocation permission to use this operation.
    @Sendable
    @inlinable
    public func getTableMetadataLocation(_ input: GetTableMetadataLocationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetTableMetadataLocationResponse {
        try await self.client.execute(
            operation: "GetTableMetadataLocation", 
            path: "/tables/{tableBucketARN}/{namespace}/{name}/metadata-location", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the location of the table metadata.  Permissions  You must have the s3tables:GetTableMetadataLocation permission to use this operation.
    ///
    /// Parameters:
    ///   - name: The name of the table.
    ///   - namespace: The namespace of the table.
    ///   - tableBucketARN: The Amazon Resource Name (ARN) of the table bucket.
    ///   - logger: Logger use during operation
    @inlinable
    public func getTableMetadataLocation(
        name: String,
        namespace: String,
        tableBucketARN: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetTableMetadataLocationResponse {
        let input = GetTableMetadataLocationRequest(
            name: name, 
            namespace: namespace, 
            tableBucketARN: tableBucketARN
        )
        return try await self.getTableMetadataLocation(input, logger: logger)
    }

    /// Gets details about a table policy. For more information, see Viewing a table policy in the Amazon Simple Storage Service User Guide.  Permissions  You must have the s3tables:GetTablePolicy permission to use this operation.
    @Sendable
    @inlinable
    public func getTablePolicy(_ input: GetTablePolicyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetTablePolicyResponse {
        try await self.client.execute(
            operation: "GetTablePolicy", 
            path: "/tables/{tableBucketARN}/{namespace}/{name}/policy", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets details about a table policy. For more information, see Viewing a table policy in the Amazon Simple Storage Service User Guide.  Permissions  You must have the s3tables:GetTablePolicy permission to use this operation.
    ///
    /// Parameters:
    ///   - name: The name of the table.
    ///   - namespace: The namespace associated with the table.
    ///   - tableBucketARN: The Amazon Resource Name (ARN) of the table bucket that contains the table.
    ///   - logger: Logger use during operation
    @inlinable
    public func getTablePolicy(
        name: String,
        namespace: String,
        tableBucketARN: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetTablePolicyResponse {
        let input = GetTablePolicyRequest(
            name: name, 
            namespace: namespace, 
            tableBucketARN: tableBucketARN
        )
        return try await self.getTablePolicy(input, logger: logger)
    }

    /// Lists the namespaces within a table bucket. For more information, see Table namespaces in the Amazon Simple Storage Service User Guide.  Permissions  You must have the s3tables:ListNamespaces permission to use this operation.
    @Sendable
    @inlinable
    public func listNamespaces(_ input: ListNamespacesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListNamespacesResponse {
        try await self.client.execute(
            operation: "ListNamespaces", 
            path: "/namespaces/{tableBucketARN}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the namespaces within a table bucket. For more information, see Table namespaces in the Amazon Simple Storage Service User Guide.  Permissions  You must have the s3tables:ListNamespaces permission to use this operation.
    ///
    /// Parameters:
    ///   - continuationToken:  ContinuationToken indicates to Amazon S3 that the list is being continued on this bucket with a token. ContinuationToken is obfuscated and is not a real key. You can use this ContinuationToken for pagination of the list results.
    ///   - maxNamespaces: The maximum number of namespaces to return in the list.
    ///   - prefix: The prefix of the namespaces.
    ///   - tableBucketARN: The Amazon Resource Name (ARN) of the table bucket.
    ///   - logger: Logger use during operation
    @inlinable
    public func listNamespaces(
        continuationToken: String? = nil,
        maxNamespaces: Int? = nil,
        prefix: String? = nil,
        tableBucketARN: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListNamespacesResponse {
        let input = ListNamespacesRequest(
            continuationToken: continuationToken, 
            maxNamespaces: maxNamespaces, 
            prefix: prefix, 
            tableBucketARN: tableBucketARN
        )
        return try await self.listNamespaces(input, logger: logger)
    }

    /// Lists table buckets for your account. For more information, see S3 Table buckets in the Amazon Simple Storage Service User Guide.  Permissions  You must have the s3tables:ListTableBuckets permission to use this operation.
    @Sendable
    @inlinable
    public func listTableBuckets(_ input: ListTableBucketsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTableBucketsResponse {
        try await self.client.execute(
            operation: "ListTableBuckets", 
            path: "/buckets", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists table buckets for your account. For more information, see S3 Table buckets in the Amazon Simple Storage Service User Guide.  Permissions  You must have the s3tables:ListTableBuckets permission to use this operation.
    ///
    /// Parameters:
    ///   - continuationToken:  ContinuationToken indicates to Amazon S3 that the list is being continued on this bucket with a token. ContinuationToken is obfuscated and is not a real key. You can use this ContinuationToken for pagination of the list results.
    ///   - maxBuckets: The maximum number of table buckets to return in the list.
    ///   - prefix: The prefix of the table buckets.
    ///   - type: The type of table buckets to filter by in the list.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTableBuckets(
        continuationToken: String? = nil,
        maxBuckets: Int? = nil,
        prefix: String? = nil,
        type: TableBucketType? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTableBucketsResponse {
        let input = ListTableBucketsRequest(
            continuationToken: continuationToken, 
            maxBuckets: maxBuckets, 
            prefix: prefix, 
            type: type
        )
        return try await self.listTableBuckets(input, logger: logger)
    }

    /// List tables in the given table bucket. For more information, see S3 Tables in the Amazon Simple Storage Service User Guide.  Permissions  You must have the s3tables:ListTables permission to use this operation.
    @Sendable
    @inlinable
    public func listTables(_ input: ListTablesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTablesResponse {
        try await self.client.execute(
            operation: "ListTables", 
            path: "/tables/{tableBucketARN}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// List tables in the given table bucket. For more information, see S3 Tables in the Amazon Simple Storage Service User Guide.  Permissions  You must have the s3tables:ListTables permission to use this operation.
    ///
    /// Parameters:
    ///   - continuationToken:  ContinuationToken indicates to Amazon S3 that the list is being continued on this bucket with a token. ContinuationToken is obfuscated and is not a real key. You can use this ContinuationToken for pagination of the list results.
    ///   - maxTables: The maximum number of tables to return.
    ///   - namespace: The namespace of the tables.
    ///   - prefix: The prefix of the tables.
    ///   - tableBucketARN: The Amazon resource Name (ARN) of the table bucket.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTables(
        continuationToken: String? = nil,
        maxTables: Int? = nil,
        namespace: String? = nil,
        prefix: String? = nil,
        tableBucketARN: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTablesResponse {
        let input = ListTablesRequest(
            continuationToken: continuationToken, 
            maxTables: maxTables, 
            namespace: namespace, 
            prefix: prefix, 
            tableBucketARN: tableBucketARN
        )
        return try await self.listTables(input, logger: logger)
    }

    /// Sets the encryption configuration for a table bucket.  Permissions  You must have the s3tables:PutTableBucketEncryption permission to use this operation.  If you choose SSE-KMS encryption you must grant the S3 Tables maintenance principal access to your KMS key. For more information, see Permissions requirements for S3 Tables SSE-KMS encryption in the Amazon Simple Storage Service User Guide.
    @Sendable
    @inlinable
    public func putTableBucketEncryption(_ input: PutTableBucketEncryptionRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "PutTableBucketEncryption", 
            path: "/buckets/{tableBucketARN}/encryption", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Sets the encryption configuration for a table bucket.  Permissions  You must have the s3tables:PutTableBucketEncryption permission to use this operation.  If you choose SSE-KMS encryption you must grant the S3 Tables maintenance principal access to your KMS key. For more information, see Permissions requirements for S3 Tables SSE-KMS encryption in the Amazon Simple Storage Service User Guide.
    ///
    /// Parameters:
    ///   - encryptionConfiguration: The encryption configuration to apply to the table bucket.
    ///   - tableBucketARN: The Amazon Resource Name (ARN) of the table bucket.
    ///   - logger: Logger use during operation
    @inlinable
    public func putTableBucketEncryption(
        encryptionConfiguration: EncryptionConfiguration,
        tableBucketARN: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = PutTableBucketEncryptionRequest(
            encryptionConfiguration: encryptionConfiguration, 
            tableBucketARN: tableBucketARN
        )
        return try await self.putTableBucketEncryption(input, logger: logger)
    }

    /// Creates a new maintenance configuration or replaces an existing maintenance configuration for a table bucket. For more information, see Amazon S3 table bucket maintenance in the Amazon Simple Storage Service User Guide.  Permissions  You must have the s3tables:PutTableBucketMaintenanceConfiguration permission to use this operation.
    @Sendable
    @inlinable
    public func putTableBucketMaintenanceConfiguration(_ input: PutTableBucketMaintenanceConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "PutTableBucketMaintenanceConfiguration", 
            path: "/buckets/{tableBucketARN}/maintenance/{type}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new maintenance configuration or replaces an existing maintenance configuration for a table bucket. For more information, see Amazon S3 table bucket maintenance in the Amazon Simple Storage Service User Guide.  Permissions  You must have the s3tables:PutTableBucketMaintenanceConfiguration permission to use this operation.
    ///
    /// Parameters:
    ///   - tableBucketARN: The Amazon Resource Name (ARN) of the table bucket associated with the maintenance configuration.
    ///   - type: The type of the maintenance configuration.
    ///   - value: Defines the values of the maintenance configuration for the table bucket.
    ///   - logger: Logger use during operation
    @inlinable
    public func putTableBucketMaintenanceConfiguration(
        tableBucketARN: String,
        type: TableBucketMaintenanceType,
        value: TableBucketMaintenanceConfigurationValue,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = PutTableBucketMaintenanceConfigurationRequest(
            tableBucketARN: tableBucketARN, 
            type: type, 
            value: value
        )
        return try await self.putTableBucketMaintenanceConfiguration(input, logger: logger)
    }

    /// Creates a new maintenance configuration or replaces an existing table bucket policy for a table bucket. For more information, see Adding a table bucket policy in the Amazon Simple Storage Service User Guide.  Permissions  You must have the s3tables:PutTableBucketPolicy permission to use this operation.
    @Sendable
    @inlinable
    public func putTableBucketPolicy(_ input: PutTableBucketPolicyRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "PutTableBucketPolicy", 
            path: "/buckets/{tableBucketARN}/policy", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new maintenance configuration or replaces an existing table bucket policy for a table bucket. For more information, see Adding a table bucket policy in the Amazon Simple Storage Service User Guide.  Permissions  You must have the s3tables:PutTableBucketPolicy permission to use this operation.
    ///
    /// Parameters:
    ///   - resourcePolicy: The JSON that defines the policy.
    ///   - tableBucketARN: The Amazon Resource Name (ARN) of the table bucket.
    ///   - logger: Logger use during operation
    @inlinable
    public func putTableBucketPolicy(
        resourcePolicy: String,
        tableBucketARN: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = PutTableBucketPolicyRequest(
            resourcePolicy: resourcePolicy, 
            tableBucketARN: tableBucketARN
        )
        return try await self.putTableBucketPolicy(input, logger: logger)
    }

    /// Creates a new maintenance configuration or replaces an existing maintenance configuration for a table. For more information, see S3 Tables maintenance in the Amazon Simple Storage Service User Guide.  Permissions  You must have the s3tables:PutTableMaintenanceConfiguration permission to use this operation.
    @Sendable
    @inlinable
    public func putTableMaintenanceConfiguration(_ input: PutTableMaintenanceConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "PutTableMaintenanceConfiguration", 
            path: "/tables/{tableBucketARN}/{namespace}/{name}/maintenance/{type}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new maintenance configuration or replaces an existing maintenance configuration for a table. For more information, see S3 Tables maintenance in the Amazon Simple Storage Service User Guide.  Permissions  You must have the s3tables:PutTableMaintenanceConfiguration permission to use this operation.
    ///
    /// Parameters:
    ///   - name: The name of the maintenance configuration.
    ///   - namespace: The namespace of the table.
    ///   - tableBucketARN: The Amazon Resource Name (ARN) of the table associated with the maintenance configuration.
    ///   - type: The type of the maintenance configuration.
    ///   - value: Defines the values of the maintenance configuration for the table.
    ///   - logger: Logger use during operation
    @inlinable
    public func putTableMaintenanceConfiguration(
        name: String,
        namespace: String,
        tableBucketARN: String,
        type: TableMaintenanceType,
        value: TableMaintenanceConfigurationValue,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = PutTableMaintenanceConfigurationRequest(
            name: name, 
            namespace: namespace, 
            tableBucketARN: tableBucketARN, 
            type: type, 
            value: value
        )
        return try await self.putTableMaintenanceConfiguration(input, logger: logger)
    }

    /// Creates a new maintenance configuration or replaces an existing table policy for a table. For more information, see Adding a table policy in the Amazon Simple Storage Service User Guide.   Permissions  You must have the s3tables:PutTablePolicy permission to use this operation.
    @Sendable
    @inlinable
    public func putTablePolicy(_ input: PutTablePolicyRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "PutTablePolicy", 
            path: "/tables/{tableBucketARN}/{namespace}/{name}/policy", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new maintenance configuration or replaces an existing table policy for a table. For more information, see Adding a table policy in the Amazon Simple Storage Service User Guide.   Permissions  You must have the s3tables:PutTablePolicy permission to use this operation.
    ///
    /// Parameters:
    ///   - name: The name of the table.
    ///   - namespace: The namespace associated with the table.
    ///   - resourcePolicy: The JSON that defines the policy.
    ///   - tableBucketARN: The Amazon Resource Name (ARN) of the table bucket that contains the table.
    ///   - logger: Logger use during operation
    @inlinable
    public func putTablePolicy(
        name: String,
        namespace: String,
        resourcePolicy: String,
        tableBucketARN: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = PutTablePolicyRequest(
            name: name, 
            namespace: namespace, 
            resourcePolicy: resourcePolicy, 
            tableBucketARN: tableBucketARN
        )
        return try await self.putTablePolicy(input, logger: logger)
    }

    /// Renames a table or a namespace. For more information, see S3 Tables in the Amazon Simple Storage Service User Guide.  Permissions  You must have the s3tables:RenameTable permission to use this operation.
    @Sendable
    @inlinable
    public func renameTable(_ input: RenameTableRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "RenameTable", 
            path: "/tables/{tableBucketARN}/{namespace}/{name}/rename", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Renames a table or a namespace. For more information, see S3 Tables in the Amazon Simple Storage Service User Guide.  Permissions  You must have the s3tables:RenameTable permission to use this operation.
    ///
    /// Parameters:
    ///   - name: The current name of the table.
    ///   - namespace: The namespace associated with the table.
    ///   - newName: The new name for the table.
    ///   - newNamespaceName: The new name for the namespace.
    ///   - tableBucketARN: The Amazon Resource Name (ARN) of the table bucket.
    ///   - versionToken: The version token of the table.
    ///   - logger: Logger use during operation
    @inlinable
    public func renameTable(
        name: String,
        namespace: String,
        newName: String? = nil,
        newNamespaceName: String? = nil,
        tableBucketARN: String,
        versionToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = RenameTableRequest(
            name: name, 
            namespace: namespace, 
            newName: newName, 
            newNamespaceName: newNamespaceName, 
            tableBucketARN: tableBucketARN, 
            versionToken: versionToken
        )
        return try await self.renameTable(input, logger: logger)
    }

    /// Updates the metadata location for a table. The metadata location of a table must be an S3 URI that begins with the table's warehouse location. The metadata location for an Apache Iceberg table must end with .metadata.json, or if the metadata file is Gzip-compressed, .metadata.json.gz.  Permissions  You must have the s3tables:UpdateTableMetadataLocation permission to use this operation.
    @Sendable
    @inlinable
    public func updateTableMetadataLocation(_ input: UpdateTableMetadataLocationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateTableMetadataLocationResponse {
        try await self.client.execute(
            operation: "UpdateTableMetadataLocation", 
            path: "/tables/{tableBucketARN}/{namespace}/{name}/metadata-location", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the metadata location for a table. The metadata location of a table must be an S3 URI that begins with the table's warehouse location. The metadata location for an Apache Iceberg table must end with .metadata.json, or if the metadata file is Gzip-compressed, .metadata.json.gz.  Permissions  You must have the s3tables:UpdateTableMetadataLocation permission to use this operation.
    ///
    /// Parameters:
    ///   - metadataLocation: The new metadata location for the table.
    ///   - name: The name of the table.
    ///   - namespace: The namespace of the table.
    ///   - tableBucketARN: The Amazon Resource Name (ARN) of the table bucket.
    ///   - versionToken: The version token of the table.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateTableMetadataLocation(
        metadataLocation: String,
        name: String,
        namespace: String,
        tableBucketARN: String,
        versionToken: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateTableMetadataLocationResponse {
        let input = UpdateTableMetadataLocationRequest(
            metadataLocation: metadataLocation, 
            name: name, 
            namespace: namespace, 
            tableBucketARN: tableBucketARN, 
            versionToken: versionToken
        )
        return try await self.updateTableMetadataLocation(input, logger: logger)
    }
}

extension S3Tables {
    /// Initializer required by `AWSService.with(middlewares:timeout:byteBufferAllocator:options)`. You are not able to use this initializer directly as there are not public
    /// initializers for `AWSServiceConfig.Patch`. Please use `AWSService.with(middlewares:timeout:byteBufferAllocator:options)` instead.
    public init(from: S3Tables, patch: AWSServiceConfig.Patch) {
        self.client = from.client
        self.config = from.config.with(patch: patch)
    }
}

// MARK: Paginators

@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
extension S3Tables {
    /// Return PaginatorSequence for operation ``listNamespaces(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listNamespacesPaginator(
        _ input: ListNamespacesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListNamespacesRequest, ListNamespacesResponse> {
        return .init(
            input: input,
            command: self.listNamespaces,
            inputKey: \ListNamespacesRequest.continuationToken,
            outputKey: \ListNamespacesResponse.continuationToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listNamespaces(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxNamespaces: The maximum number of namespaces to return in the list.
    ///   - prefix: The prefix of the namespaces.
    ///   - tableBucketARN: The Amazon Resource Name (ARN) of the table bucket.
    ///   - logger: Logger used for logging
    @inlinable
    public func listNamespacesPaginator(
        maxNamespaces: Int? = nil,
        prefix: String? = nil,
        tableBucketARN: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListNamespacesRequest, ListNamespacesResponse> {
        let input = ListNamespacesRequest(
            maxNamespaces: maxNamespaces, 
            prefix: prefix, 
            tableBucketARN: tableBucketARN
        )
        return self.listNamespacesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listTableBuckets(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listTableBucketsPaginator(
        _ input: ListTableBucketsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListTableBucketsRequest, ListTableBucketsResponse> {
        return .init(
            input: input,
            command: self.listTableBuckets,
            inputKey: \ListTableBucketsRequest.continuationToken,
            outputKey: \ListTableBucketsResponse.continuationToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listTableBuckets(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxBuckets: The maximum number of table buckets to return in the list.
    ///   - prefix: The prefix of the table buckets.
    ///   - type: The type of table buckets to filter by in the list.
    ///   - logger: Logger used for logging
    @inlinable
    public func listTableBucketsPaginator(
        maxBuckets: Int? = nil,
        prefix: String? = nil,
        type: TableBucketType? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListTableBucketsRequest, ListTableBucketsResponse> {
        let input = ListTableBucketsRequest(
            maxBuckets: maxBuckets, 
            prefix: prefix, 
            type: type
        )
        return self.listTableBucketsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listTables(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listTablesPaginator(
        _ input: ListTablesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListTablesRequest, ListTablesResponse> {
        return .init(
            input: input,
            command: self.listTables,
            inputKey: \ListTablesRequest.continuationToken,
            outputKey: \ListTablesResponse.continuationToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listTables(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxTables: The maximum number of tables to return.
    ///   - namespace: The namespace of the tables.
    ///   - prefix: The prefix of the tables.
    ///   - tableBucketARN: The Amazon resource Name (ARN) of the table bucket.
    ///   - logger: Logger used for logging
    @inlinable
    public func listTablesPaginator(
        maxTables: Int? = nil,
        namespace: String? = nil,
        prefix: String? = nil,
        tableBucketARN: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListTablesRequest, ListTablesResponse> {
        let input = ListTablesRequest(
            maxTables: maxTables, 
            namespace: namespace, 
            prefix: prefix, 
            tableBucketARN: tableBucketARN
        )
        return self.listTablesPaginator(input, logger: logger)
    }
}

extension S3Tables.ListNamespacesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> S3Tables.ListNamespacesRequest {
        return .init(
            continuationToken: token,
            maxNamespaces: self.maxNamespaces,
            prefix: self.prefix,
            tableBucketARN: self.tableBucketARN
        )
    }
}

extension S3Tables.ListTableBucketsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> S3Tables.ListTableBucketsRequest {
        return .init(
            continuationToken: token,
            maxBuckets: self.maxBuckets,
            prefix: self.prefix,
            type: self.type
        )
    }
}

extension S3Tables.ListTablesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> S3Tables.ListTablesRequest {
        return .init(
            continuationToken: token,
            maxTables: self.maxTables,
            namespace: self.namespace,
            prefix: self.prefix,
            tableBucketARN: self.tableBucketARN
        )
    }
}
